Using the spelling checker/corrector.

	Incant the command:  "R SPELL" to invoke the  spelling  check
program.  Assuming  that all is normal, it will type: "Do you want to
augment the dictionary?" If you don't have  an  auxiliary  dictionary
anywhere then type <return> and forget the next paragraph.

	If  you have a dictionary that you want to load then type "Y"
and <return> and you will be asked for the name  of  your  dictionary
file.  The dictionary file must be on disk. The format of the file is
one dictionary entry  (word)  on  a  line;  words  must  be  strictly
alphabetic  characters  and less than 40 letters long. The dictionary
entries need not be in alphabetical order.   After  typing  the  file
name  you  will  be  asked whether you want the new entries marked as
incremental  insertions.     If  the  new  entries  are   marked   as
incremental  then they will be included in an incremental dump of the
dictionary.    To have the new entries marked as incremental type "I"
and <return>, otherwise, type <return>.  (If any of the words in your
auxiliary dictionary are already  in  the  main  dictionary  then  no
second copy of the word will be made.  Hence if your words are marked
as incremental then in a subsequent incremental dump, any words  that
were  already in the dictionary will not be dumped.) After loading an
auxiliary dictionary the program will type the total number of  words
in  the dictionary and the amount of core used.  At present there are
about 10,700 words in the dictionary, using  35K  of  core.     After
loading  an  auxiliary,  you will have an opportunity to save the new
core image on your disk area (probably not worth it). Also  you  will
get an opportunity to load another auxiliary dictionary.

	Next you will be asked for the name of the file that you want
to check for spelling errors.  File names are specified in the  usual
format  of "name.ext[prj,prg]" where name is the filename, ext is the
file extension, and [prj,prg] is the name of the  file  owner,  which
may be omitted if the file is on the present user's disk area. If you
omit the file name then you will immediately enter the exit  sequence
(see below).

	You will be asked to specify a name for the output file.  The
output file is where the corrected version of the input goes.  If you
omit this name then no corrections will be made. (Only the exceptions
will  typed,  and  if  you  specify an exception file then it will be
made).

	You  will be asked to name an exception file.  This file will
contain all the lines on which exceptions were found and the rejected
words.  (This  file  is  probably not worth it). If you omit the name
then no such file will be created.

	After you have specified all the files, the program ought  to
respond  with  "working..."  and  start  checking  the input file for
spelling errors.

	When the spelling checker encounters a word that isn't in the
dictionary, it will type the page number, the line on which the  word
was  found  and  the word itself.  The very first time this happens a
message that explains the choices you have will be typed.

	These choices are:

A	Accept this word, this one time.

I	Accept this word and insert it  in  the  dictionary  so  that
subsequent  occurences  of this word will be recognized and accepted.
Words that are inserted this way are marked as incremental insertions
and they may be dumped to form an auxiliary dictionary.

R	Replace  this  word.   Type "R" <return> and the program will
ask you for the replacement word.  If the  replacement  word  is  not
already  in  the dictionary, the program will give you an opportunity
to insert it.

X	Accept this word and finish.  The word will be accepted. Then
the  remainder  of  the input file will be copied without checking to
the output file.

W	Save my incremental insertions.  After you type "W"  <return>
you  will  be asked for a file name.  Then an incremental dump of the
dictionary will be written into the file.  After the dump is complete
you may then decide what to do with the excepted word.

D	Display  the  line and offending word again. The line that is
displayed will not have any corrections shown in it. If  a  line  has
more  than  one  error the line will only be typed once.   Subsequent
errors on that line will cause only the particular word to be  typed,
unless this command is used.

S	If  this  choice  is  offered  then  the spelling checker has
discovered several words that could be possible corrections  of  this
word.   If you type "S" <return> then you will enter a mode where you
can look at the words that found  by  the  program  and  (optionally)
select one of the words from the list.

	When  you  enter this selection submode for the first time an
explanation will be typed.  The first word in the  list  of  possible
corrections  will be typed followed by an asterisk. Then you have the
following choices.

	Y<return>	Use this word as the correction.

	<return>	Show the next  possible  choice.    When  you
exhaust  the  choices  you  are returned to the outer mode, and asked
again.

	↑<return>	Back up in the list.

	<alt mode>	Escape from this submode and  return  to  the
outer command mode.

	In  general,  when  a  word  is  found  that  is  not  in the
dictionary a brief message, either "Type A,I,R,X,W  or  D"  or  "Type
A,I,R,X,W,D  or  S"  will  be  typed  to  remind  you of the possible
choices.   In the special case that the  program  finds  exactly  one
possible  correction  for the word, then the message "I guess <word>.
Type C to make this correction or A,I,R,X,W or D" will be typed.   If
you  type  "C"  <return>  then  the indicated substitution will made,
otherwise you have the usual choices.

	When the input file is  exhausted  the  correction  file  and
exception  file  are  closed  and  all I/O channels are released. The
program types "Finished."

	The exit sequence is entered next.  The user is given several
options.  They are:

E	Exit now.

S	Save this core image

C	Go back and correct another file.

A	Augment the dictionary and correct another file.

D	Complete  dump of the dictionary to disk.  This will create a
17 or 18K file, which probably isn't worth it.

I	Incremental dump of the dictionary to disk.   All  the  words
that  were inserted while running the program are dumped to the disk.
The user specifies a file name (the  default  is  WORDS.LST).    This
incremental dump is in a format suitable for editing or for use as an
auxiliary dictionary.  The words in this dump are not in alphabetical
order.    These  words  will appear in groups sorted by the first two
letters of the word and by the length of the word.  Otherwise, within
a group the words will appear in last in - first out order.

X	This command is used to get a trace count of the program.  It
is for diagnostic purposes only.

		How to use multiple dictionaries


	Spell  has  a  set of features whereby the user can cause the
creation of several disjoint incremental dictionaries.  In this  way,
the   user   may  collect  several  dictionaries  of  special  terms.
Internally,  all dictionary  entries  are  considered  equivalent  as
regards  searches  for  words.   The distinction between dictionaries
has its greatest impact when doing incremental dumps (the  I  command
during  the  exit  sequence  or  the W command while in the middle of
execution).  When an incremental dump  is  requested,  the  user  may
specify  a  number, e.g. W9, which selects the particular incremental
dictionary to dump.  In this example, dictionary #9 will be dumped.

	Dictionary 0 is the main dictionary.  Words cannot  be  added
to this dictionary, except by reading an auxiliary file.  In general,
words  that  are  inserted  incrementally  are  marked  as  being  in
dictionary  #1.   All  words  that  are incremental insertions in the
dictionary  will  be  marked  in  dictionary  #1,  unless  the   user
specifies otherwise.

	The following places are where the  user  may  specify  which
dictionary to add to:

	1.	When loading an auxiliary  dictionary,  if  the  user
responds  with  "Inn"  to  the  question about marking new entries as
incremental, then the new entries will be marked in dictionary number
nn (where nn is interpreted as decimal and should be less than 32).

	2.	After  a word has been rejected, type "Inn" to insert
the word in dictionary number nn.

	3.	After replacing a word, if the replacement is not  in
the  dictionary  then  type  "Inn"  to  insert  the  replacement into
dictionary nn.


	When requesting an incremental dump, the user may specify the
particular dictionary to dump.  This is allowed in two cases:

	1.	After some word has been rejected, the command  "Wnn"
will cause dictionary number nn to dumped.

	2.	During  the  exit  sequence,  the  command "Inn" will
cause dictionary number nn to be dumped.


	In  all  five cases above, if nn is either 0 or omitted, then
it will be taken as being 1.

	Caution. There is no provision in Spell for remembering which
dictionary  numbers  have  been  used.    Therefore,  it  remains the
individual user's responsibility to remember the numbers of  all  the
dictionaries  that he creates.  (Forgetting the number will mean that
the forgotten dictionary can not be dumped incrementally.  The  words
in  a  forgotten dictionary will still be available, but the only way
to actually get them dumped out is to dump the entire dictionary).


		The Pickup Feature.

	If any of the three file names in the  entry  sequence (where
the source, correction and exception files are specified) is followed
by the switch "/P" then, after accepting the three file names,  SPELL
will  enter  pickup  mode.   The user will be asked to specify a page
number and, if the file is in SOS format, a line number  for  pickup.
The  effect  is  to suspend spelling checking until the page and line
specified.   When a user has a partially corrected file, this command
will enable him to skip over the portion of the file that has already
been corrected.  The input file will be copied  without  checking  to
the output until the page and line specified, at which point spelling
checking begins.


		The Training feature.

	If  the file name of the input file is followed by the switch
"/T" then instead of correcting the file, Spell will treat  the  file
as  a  training  set.   All  words in the file that are unfamiliar to
Spell will be entered in the dictionary  as  incremental  insertions.
After Spell finishes reading the file, the user has an opportunity to
dump all the words that were inserted this way.  The  resulting  list
of words  may  be  edited  and  any  words which are incorrect may be
deleted.  Then this file can be used as an auxiliary dictionary while
correcting the original source file.

	This  feature  is  provided  for  the  purpose  of easing the
problem  of  creating  a  specialized  dictionary   of   jargon   and
infrequently used words.

	-------------------------------------------------

			Abnormal Conditions.

	While the program is running  it  is  possible  that  certain
abnormal conditions may obtain.  The usual response of the program is
to type some sort of error message.

	The following is a list of the error messages in SPELL,  with
an indication of the severity of the error.

Huh?		The  user  has  typed something illegal.   He will be
given another chance, usually  after  reviewing  the  list  of  valid
responses.

Default name is WORDS.LST	The  user  has  typed <return> when a
name for a dictionary output file was requested.  The name  Words.Lst
is used.

Default name is SPELL.DMP	The  user  has  typed <return> when a
name for a core dump file was requested. The name Spell.Dmp is used.

Illegal dictionary entry: <word>	This error occurs if an entry
in  a  dictionary  file exceeds 40 (decimal) characters.  The word is
ignored.

0 LENGTH WORD AT HASHCP		Somebody just asked  to  compute  the
hash address of an empty word.  The program continues, but there is a
possibility of great evilness.

HASHING ERROR			Somebody asked for the  hash  address
of  a  word  that  doesn't  begin  with  letters  as  the  first  two
characters. The program halts.

ILLEGAL CHARACTER IN SCAN.	This is a message  from  the  routine
that reads file names.  You will be asked to try retyping the name.

Can't get there from here	This   means  that  from  the  select
submode you typed ↑ to see the previous choice and you  were  at  the
first choice. The first choice is repeated.

DEVICE DATA ERROR (OUTPUT)	This message means that while writing
a file, something screwed up.  The program halts.

DEVICE ERROR (INPUT)		The input file is screwed up in  some
way.  The program halts.

INIT FAILED ON DEVICE DSK:	This  indicates  tremendous confusion
external to this program.  The program halts.

FILE NOT FOUND. DSK:<filename>	The  indicated  file  could  not   be
found. The user gets to specify some other file.

Enter failed on: <file name>	An  enter  uuo failed while trying to
select the indicated file for output.  The user may  specify  another
name.

INSUFFICIENT CORE AVAILABLE.  I GIVE UP.	Program requires more
core, but none is available.  The program exits.

Null term illegal.		The user typed <return> where a  file
name  is  needed.   The  user  has another opportunity to specify the
name.

Internal confusion in the  spelling  checker.  Called  from  location
<loc>.  The  spelling  checker  has  discovered  a  (possible) bug in
itself.   The program halts, but the user may type continue.   Please
note  the  location  mentioned  and the circumstances that evoked the
message.

Dictionary number too large. Maximum is 31.	This  message   means
that  the  user  attempted  to  select  for  insertion  or  dumping a
dictionary beyond the range of allowed numbers.  The  user  will  get
another chance to do the right thing.

You can't use Training Switch and have output or exceptions.	This
message  occurs  when  the switch "/T" is typed following the name of
the output or exception file.  If the "/T" switch is used, it  should
follow the name of the input file.

Unrecognized switch.	This message is typed whenever a file name is
followed by a switch that is not one of the Spell switches.